home *** CD-ROM | disk | FTP | other *** search
/ Mac-Source 1994 July / Mac-Source_July_1994.iso / Other Langs / MacPerl ƒ / Perl Source ƒ / Perl / icemalloc.h < prev    next >
Text File  |  1993-10-23  |  5KB  |  176 lines

  1.  
  2. /*
  3. **
  4. ** Notice.
  5. **
  6. ** This source code was written by Tim Endres. time@ice.com
  7. ** Copyright 1988-1991 © By Tim Endres. All rights reserved.
  8. **
  9. ** You may use this source code for any purpose you can dream
  10. ** of as long as this notice is never modified nor removed.
  11. **
  12. */
  13.  
  14. #include <sys/types.h>
  15.  
  16. /*
  17. ** Right now we are limiting the maximum single allocation unit to 16Meg.
  18. ** This way we can stuff the index to the next ptr hdr into the
  19. ** low 24 bits of a long, then slam 8 bits of flag information
  20. ** into the upper 8 bits of the same long. Not necessarily beautiful
  21. ** but compact and functional.
  22. */
  23.  
  24. /*
  25. **    _PM_DEBUG_LEVEL
  26. **
  27. **  1 - DPRINTF ERROR conditions.
  28. **  2 - DPRINTF *AND* DACTION ERROR conditions.
  29. **
  30. **  3 - DPRINTF WARNING conditions.
  31. **  5 - DPRINTF DEBUGING conditions.
  32. ** 10 - DPRINTF NOTES conditions.
  33. **
  34. */
  35.  
  36. #ifdef DEBUG
  37.  
  38. #    define _PM_STATS
  39. #    define _PM_DYNAMIC_MERGING
  40. #    define _PM_DYNAMIC_FREE
  41.  
  42. #    define    _PM_DEBUG_LEVEL        1
  43.  
  44. #    define DPRINTF(level, parms)    { if ((level) <= pool_malloc_debug_level) { printf parms ; } }
  45. #    define DACTION(level, action)    { if ((level) <= pool_malloc_debug_level) { action } }
  46.  
  47. int        pool_malloc_debug_level = _PM_DEBUG_LEVEL;
  48.  
  49. #else
  50.  
  51. #    define _PM_DYNAMIC_MERGING
  52. #    define _PM_DYNAMIC_FREE
  53.  
  54. #    define    _PM_DEBUG_LEVEL        0
  55.  
  56. #    define DPRINTF(level, parms)
  57. #    define DACTION(level, action)
  58.  
  59. #endif DEVELOPMENT
  60.  
  61.  
  62. /*
  63. ** MEMORY PTR HEADER FLAG BITS:
  64. **
  65. ** 01 _PM_PTR_FREE        Is this piece of memory free?
  66. ** 02
  67. ** 04
  68. ** 08
  69. **
  70. ** 10
  71. ** 20
  72. ** 40
  73. ** 80 _PM_PTR_PARITY    This is a parity bit for debugging.
  74. **
  75. */
  76.  
  77. #define _PM_PTR_USED        0x01
  78. #define _PM_PTR_PARITY        0x80
  79.  
  80. #define _PM_MIN_ALLOC_SIZE    8
  81.  
  82. #define    ALIGNMENT                4        /* The 68020 likes things long aligned. */
  83. #define INT_ALIGN(i, r)            ( ((i) + ((r) - 1)) & ~((r) - 1) )
  84.  
  85.  
  86. #define SUGGESTED_BLK_SIZE        32767
  87.  
  88.  
  89. #define GET_PTR_FLAGS(hdr)    \
  90.     ( (u_long) ( (((hdr)->size) >> 24) & 0x000000FF ) )
  91. #define SET_PTR_USED(hdr)    \
  92.     ( (hdr)->size |= (((_PM_PTR_USED) << 24) & 0xFF000000) )
  93. #define SET_PTR_FREE(hdr)    \
  94.     ( (hdr)->size &= ~(((_PM_PTR_USED) << 24) & 0xFF000000) )
  95. #define IS_PTR_USED(hdr)    \
  96.     ( (GET_PTR_FLAGS(hdr) & _PM_PTR_USED) != 0 )
  97. #define IS_PTR_FREE(hdr)    \
  98.     ( (GET_PTR_FLAGS(hdr) & _PM_PTR_USED) == 0 )
  99.  
  100. #define GET_PTR_SIZE(hdr)    \
  101.     ( (u_long) ( ((hdr)->size) & 0x00FFFFFF ) )
  102. #define SET_PTR_SIZE(hdr, blksize)    \
  103.     ( (hdr)->size = ( ((hdr)->size & 0XFF000000) | ((blksize) & 0x00FFFFFF) ) )
  104.  
  105. typedef struct {
  106.     u_long        size;
  107.     } _mem_ptr_hdr, *_mem_ptr_hdr_ptr;
  108.  
  109.  
  110. typedef struct _MEM_BLK {
  111.     u_long                size;            /* The size of this block's memory. */
  112.     char                *memory;        /* The block's allocated memory. */
  113.     u_long                max_free;        /* The maximum free size in the block */
  114.     struct _MEM_BLK        *next;            /* The next block in the pool block list. */
  115.     struct _MEM_POOL    *pool;            /* The block's pool. */
  116.     } _mem_blk, *_mem_blk_ptr;
  117.  
  118.  
  119. typedef struct _MEM_POOL {
  120.     int                    id;                /* The pool's ID. */
  121.     u_long                pref_blk_size;    /* The preferred size of new blks. */
  122.     _mem_blk_ptr        blk_list;        /* The list of blocks in the pool. */
  123.     struct _MEM_POOL    *next;            /* The next pool in the forest. */
  124. #ifdef _PM_STATS
  125.     u_long                total_memory;    /* The total allocated memory by this pool */
  126.     u_long                total_storage;    /* The total malloc-able storage in this pool */
  127.     u_long                total_malloc;    /* The total malloc-ed storage not freed. */
  128.     u_long                max_blk_size;    /* The maximum block size allocated. */
  129.     float                ave_req_size;    /* The ave allocated request size */
  130.     u_long                ave_req_total;    /* The total requests in the average. */
  131.     float                ave_blk_size;    /* The ave sallocated blk size */
  132.     u_long                ave_blk_total;    /* The total blks in the average. */
  133. #endif
  134.     } _mem_pool, *_mem_pool_ptr;
  135.  
  136.  
  137.  
  138. static _mem_pool    _mem_system_pool = {
  139.     0,                        /* id */
  140.     SUGGESTED_BLK_SIZE,        /* pref_blk_size */
  141.     0,                        /* blk_list */
  142.     0,                        /* next */
  143. #ifdef _PM_STATS
  144.     0,                        /* total_memory */
  145.     0,                        /* total_storage */
  146.     0,                        /* total_malloc */
  147.     0,                        /* max_blk_size */
  148.     0.0,                    /* ave_req_size */
  149.     0,                        /* ave_req_total */
  150.     0.0,                    /* ave_blk_size */
  151.     0,                        /* ave_blk_total */
  152. #endif
  153.     };
  154.  
  155. /*
  156. ** The memory pool forest. To the user, this is simply a disjoint
  157. ** group of memory pools, in which his memory pools lie. We keep
  158. ** it as a simple linked list. Forward linked, nothing fancy.
  159. **
  160. ** The default pool is simply the front pool in the pool forest list.
  161. */
  162. _mem_pool_ptr                _mem_pool_forest = & _mem_system_pool;
  163.  
  164. #define _default_mem_pool    _mem_pool_forest
  165.  
  166.  
  167. char                *malloc();
  168. char                *_pool_malloc();
  169. _mem_blk_ptr        _pool_new_blk();
  170. _mem_blk_ptr        _pool_find_free_blk();
  171. _mem_blk_ptr        _pool_find_ptr_blk();
  172. _mem_ptr_hdr_ptr    _blk_find_free_hdr();
  173. _mem_pool_ptr        find_pool();
  174. _mem_pool_ptr        new_malloc_pool();
  175. int                    set_default_pool();    
  176.